home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / compiler / transformer.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  40KB  |  1,394 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. '''Parse tree transformation module.
  5.  
  6. Transforms Python source code into an abstract syntax tree (AST)
  7. defined in the ast module.
  8.  
  9. The simplest ways to invoke this module are via parse and parseFile.
  10. parse(buf) -> AST
  11. parseFile(path) -> AST
  12. '''
  13. from compiler.ast import *
  14. import parser
  15. import symbol
  16. import token
  17. import sys
  18.  
  19. class WalkerError(StandardError):
  20.     pass
  21.  
  22. from consts import CO_VARARGS, CO_VARKEYWORDS
  23. from consts import OP_ASSIGN, OP_DELETE, OP_APPLY
  24.  
  25. def parseFile(path):
  26.     f = open(path, 'U')
  27.     src = f.read() + '\n'
  28.     f.close()
  29.     return parse(src)
  30.  
  31.  
  32. def parse(buf, mode = 'exec'):
  33.     if mode == 'exec' or mode == 'single':
  34.         return Transformer().parsesuite(buf)
  35.     elif mode == 'eval':
  36.         return Transformer().parseexpr(buf)
  37.     else:
  38.         raise ValueError("compile() arg 3 must be 'exec' or 'eval' or 'single'")
  39.  
  40.  
  41. def asList(nodes):
  42.     l = []
  43.     for item in nodes:
  44.         if hasattr(item, 'asList'):
  45.             l.append(item.asList())
  46.             continue
  47.         if type(item) is type((None, None)):
  48.             l.append(tuple(asList(item)))
  49.             continue
  50.         if type(item) is type([]):
  51.             l.append(asList(item))
  52.             continue
  53.         l.append(item)
  54.     
  55.     return l
  56.  
  57.  
  58. def extractLineNo(ast):
  59.     if not isinstance(ast[1], tuple):
  60.         return ast[2]
  61.     
  62.     for child in ast[1:]:
  63.         if isinstance(child, tuple):
  64.             lineno = extractLineNo(child)
  65.             if lineno is not None:
  66.                 return lineno
  67.             
  68.         lineno is not None
  69.     
  70.  
  71.  
  72. def Node(*args):
  73.     kind = args[0]
  74.     if nodes.has_key(kind):
  75.         
  76.         try:
  77.             return nodes[kind](*args[1:])
  78.         except TypeError:
  79.             print nodes[kind], len(args), args
  80.             raise 
  81.         except:
  82.             None<EXCEPTION MATCH>TypeError
  83.         
  84.  
  85.     None<EXCEPTION MATCH>TypeError
  86.     raise WalkerError, "Can't find appropriate Node type: %s" % str(args)
  87.  
  88.  
  89. class Transformer:
  90.     '''Utility object for transforming Python parse trees.
  91.  
  92.     Exposes the following methods:
  93.         tree = transform(ast_tree)
  94.         tree = parsesuite(text)
  95.         tree = parseexpr(text)
  96.         tree = parsefile(fileob | filename)
  97.     '''
  98.     
  99.     def __init__(self):
  100.         self._dispatch = { }
  101.         for value, name in symbol.sym_name.items():
  102.             if hasattr(self, name):
  103.                 self._dispatch[value] = getattr(self, name)
  104.                 continue
  105.         
  106.         self._dispatch[token.NEWLINE] = self.com_NEWLINE
  107.         self._atom_dispatch = {
  108.             token.LPAR: self.atom_lpar,
  109.             token.LSQB: self.atom_lsqb,
  110.             token.LBRACE: self.atom_lbrace,
  111.             token.BACKQUOTE: self.atom_backquote,
  112.             token.NUMBER: self.atom_number,
  113.             token.STRING: self.atom_string,
  114.             token.NAME: self.atom_name }
  115.         self.encoding = None
  116.  
  117.     
  118.     def transform(self, tree):
  119.         '''Transform an AST into a modified parse tree.'''
  120.         if not isinstance(tree, tuple) or isinstance(tree, list):
  121.             tree = parser.ast2tuple(tree, line_info = 1)
  122.         
  123.         return self.compile_node(tree)
  124.  
  125.     
  126.     def parsesuite(self, text):
  127.         '''Return a modified parse tree for the given suite text.'''
  128.         return self.transform(parser.suite(text))
  129.  
  130.     
  131.     def parseexpr(self, text):
  132.         '''Return a modified parse tree for the given expression text.'''
  133.         return self.transform(parser.expr(text))
  134.  
  135.     
  136.     def parsefile(self, file):
  137.         '''Return a modified parse tree for the contents of the given file.'''
  138.         if type(file) == type(''):
  139.             file = open(file)
  140.         
  141.         return self.parsesuite(file.read())
  142.  
  143.     
  144.     def compile_node(self, node):
  145.         n = node[0]
  146.         if n == symbol.encoding_decl:
  147.             self.encoding = node[2]
  148.             node = node[1]
  149.             n = node[0]
  150.         
  151.         if n == symbol.single_input:
  152.             return self.single_input(node[1:])
  153.         
  154.         if n == symbol.file_input:
  155.             return self.file_input(node[1:])
  156.         
  157.         if n == symbol.eval_input:
  158.             return self.eval_input(node[1:])
  159.         
  160.         if n == symbol.lambdef:
  161.             return self.lambdef(node[1:])
  162.         
  163.         if n == symbol.funcdef:
  164.             return self.funcdef(node[1:])
  165.         
  166.         if n == symbol.classdef:
  167.             return self.classdef(node[1:])
  168.         
  169.         raise WalkerError, ('unexpected node type', n)
  170.  
  171.     
  172.     def single_input(self, node):
  173.         n = node[0][0]
  174.         if n != token.NEWLINE:
  175.             return self.com_stmt(node[0])
  176.         
  177.         return Pass()
  178.  
  179.     
  180.     def file_input(self, nodelist):
  181.         doc = self.get_docstring(nodelist, symbol.file_input)
  182.         if doc is not None:
  183.             i = 1
  184.         else:
  185.             i = 0
  186.         stmts = []
  187.         for node in nodelist[i:]:
  188.             if node[0] != token.ENDMARKER and node[0] != token.NEWLINE:
  189.                 self.com_append_stmt(stmts, node)
  190.                 continue
  191.         
  192.         return Module(doc, Stmt(stmts))
  193.  
  194.     
  195.     def eval_input(self, nodelist):
  196.         return Expression(self.com_node(nodelist[0]))
  197.  
  198.     
  199.     def decorator_name(self, nodelist):
  200.         listlen = len(nodelist)
  201.         item = self.atom_name(nodelist)
  202.         i = 1
  203.         while i < listlen:
  204.             item = Getattr(item, nodelist[i + 1][1])
  205.             i += 2
  206.         return item
  207.  
  208.     
  209.     def decorator(self, nodelist):
  210.         funcname = self.decorator_name(nodelist[1][1:])
  211.         if len(nodelist) > 3:
  212.             expr = self.com_call_function(funcname, nodelist[3])
  213.         else:
  214.             expr = funcname
  215.         return expr
  216.  
  217.     
  218.     def decorators(self, nodelist):
  219.         items = []
  220.         for dec_nodelist in nodelist:
  221.             items.append(self.decorator(dec_nodelist[1:]))
  222.         
  223.         return Decorators(items)
  224.  
  225.     
  226.     def funcdef(self, nodelist):
  227.         if len(nodelist) == 6:
  228.             decorators = self.decorators(nodelist[0][1:])
  229.         else:
  230.             decorators = None
  231.         lineno = nodelist[-4][2]
  232.         name = nodelist[-4][1]
  233.         args = nodelist[-3][2]
  234.         if args[0] == symbol.varargslist:
  235.             (names, defaults, flags) = self.com_arglist(args[1:])
  236.         else:
  237.             names = defaults = ()
  238.             flags = 0
  239.         doc = self.get_docstring(nodelist[-1])
  240.         code = self.com_node(nodelist[-1])
  241.         if doc is not None:
  242.             del code.nodes[0]
  243.         
  244.         return Function(decorators, name, names, defaults, flags, doc, code, lineno = lineno)
  245.  
  246.     
  247.     def lambdef(self, nodelist):
  248.         if nodelist[2][0] == symbol.varargslist:
  249.             (names, defaults, flags) = self.com_arglist(nodelist[2][1:])
  250.         else:
  251.             names = defaults = ()
  252.             flags = 0
  253.         code = self.com_node(nodelist[-1])
  254.         return Lambda(names, defaults, flags, code, lineno = nodelist[1][2])
  255.  
  256.     
  257.     def classdef(self, nodelist):
  258.         name = nodelist[1][1]
  259.         doc = self.get_docstring(nodelist[-1])
  260.         if nodelist[2][0] == token.COLON:
  261.             bases = []
  262.         else:
  263.             bases = self.com_bases(nodelist[3])
  264.         code = self.com_node(nodelist[-1])
  265.         if doc is not None:
  266.             del code.nodes[0]
  267.         
  268.         return Class(name, bases, doc, code, lineno = nodelist[1][2])
  269.  
  270.     
  271.     def stmt(self, nodelist):
  272.         return self.com_stmt(nodelist[0])
  273.  
  274.     small_stmt = stmt
  275.     flow_stmt = stmt
  276.     compound_stmt = stmt
  277.     
  278.     def simple_stmt(self, nodelist):
  279.         stmts = []
  280.         for i in range(0, len(nodelist), 2):
  281.             self.com_append_stmt(stmts, nodelist[i])
  282.         
  283.         return Stmt(stmts)
  284.  
  285.     
  286.     def parameters(self, nodelist):
  287.         raise WalkerError
  288.  
  289.     
  290.     def varargslist(self, nodelist):
  291.         raise WalkerError
  292.  
  293.     
  294.     def fpdef(self, nodelist):
  295.         raise WalkerError
  296.  
  297.     
  298.     def fplist(self, nodelist):
  299.         raise WalkerError
  300.  
  301.     
  302.     def dotted_name(self, nodelist):
  303.         raise WalkerError
  304.  
  305.     
  306.     def comp_op(self, nodelist):
  307.         raise WalkerError
  308.  
  309.     
  310.     def trailer(self, nodelist):
  311.         raise WalkerError
  312.  
  313.     
  314.     def sliceop(self, nodelist):
  315.         raise WalkerError
  316.  
  317.     
  318.     def argument(self, nodelist):
  319.         raise WalkerError
  320.  
  321.     
  322.     def expr_stmt(self, nodelist):
  323.         en = nodelist[-1]
  324.         exprNode = self.lookup_node(en)(en[1:])
  325.         if len(nodelist) == 1:
  326.             return Discard(exprNode, lineno = exprNode.lineno)
  327.         
  328.         if nodelist[1][0] == token.EQUAL:
  329.             nodesl = []
  330.             for i in range(0, len(nodelist) - 2, 2):
  331.                 nodesl.append(self.com_assign(nodelist[i], OP_ASSIGN))
  332.             
  333.             return Assign(nodesl, exprNode, lineno = nodelist[1][2])
  334.         else:
  335.             lval = self.com_augassign(nodelist[0])
  336.             op = self.com_augassign_op(nodelist[1])
  337.             return AugAssign(lval, op[1], exprNode, lineno = op[2])
  338.         raise WalkerError, "can't get here"
  339.  
  340.     
  341.     def print_stmt(self, nodelist):
  342.         items = []
  343.         if len(nodelist) == 1:
  344.             start = 1
  345.             dest = None
  346.         elif nodelist[1][0] == token.RIGHTSHIFT:
  347.             dest = self.com_node(nodelist[2])
  348.             start = 4
  349.         else:
  350.             dest = None
  351.             start = 1
  352.         for i in range(start, len(nodelist), 2):
  353.             items.append(self.com_node(nodelist[i]))
  354.         
  355.         if nodelist[-1][0] == token.COMMA:
  356.             return Print(items, dest, lineno = nodelist[0][2])
  357.         
  358.         return Printnl(items, dest, lineno = nodelist[0][2])
  359.  
  360.     
  361.     def del_stmt(self, nodelist):
  362.         return self.com_assign(nodelist[1], OP_DELETE)
  363.  
  364.     
  365.     def pass_stmt(self, nodelist):
  366.         return Pass(lineno = nodelist[0][2])
  367.  
  368.     
  369.     def break_stmt(self, nodelist):
  370.         return Break(lineno = nodelist[0][2])
  371.  
  372.     
  373.     def continue_stmt(self, nodelist):
  374.         return Continue(lineno = nodelist[0][2])
  375.  
  376.     
  377.     def return_stmt(self, nodelist):
  378.         if len(nodelist) < 2:
  379.             return Return(Const(None), lineno = nodelist[0][2])
  380.         
  381.         return Return(self.com_node(nodelist[1]), lineno = nodelist[0][2])
  382.  
  383.     
  384.     def yield_stmt(self, nodelist):
  385.         return Yield(self.com_node(nodelist[1]), lineno = nodelist[0][2])
  386.  
  387.     
  388.     def raise_stmt(self, nodelist):
  389.         if len(nodelist) > 5:
  390.             expr3 = self.com_node(nodelist[5])
  391.         else:
  392.             expr3 = None
  393.         if len(nodelist) > 3:
  394.             expr2 = self.com_node(nodelist[3])
  395.         else:
  396.             expr2 = None
  397.         if len(nodelist) > 1:
  398.             expr1 = self.com_node(nodelist[1])
  399.         else:
  400.             expr1 = None
  401.         return Raise(expr1, expr2, expr3, lineno = nodelist[0][2])
  402.  
  403.     
  404.     def import_stmt(self, nodelist):
  405.         return self.com_node(nodelist[0])
  406.  
  407.     
  408.     def import_name(self, nodelist):
  409.         return Import(self.com_dotted_as_names(nodelist[1]), lineno = nodelist[0][2])
  410.  
  411.     
  412.     def import_from(self, nodelist):
  413.         fromname = self.com_dotted_name(nodelist[1])
  414.         if nodelist[3][0] == token.STAR:
  415.             return From(fromname, [
  416.                 ('*', None)], lineno = nodelist[0][2])
  417.         else:
  418.             node = nodelist[3 + (nodelist[3][0] == token.LPAR)]
  419.             return From(fromname, self.com_import_as_names(node), lineno = nodelist[0][2])
  420.  
  421.     
  422.     def global_stmt(self, nodelist):
  423.         names = []
  424.         for i in range(1, len(nodelist), 2):
  425.             names.append(nodelist[i][1])
  426.         
  427.         return Global(names, lineno = nodelist[0][2])
  428.  
  429.     
  430.     def exec_stmt(self, nodelist):
  431.         expr1 = self.com_node(nodelist[1])
  432.         if len(nodelist) >= 4:
  433.             expr2 = self.com_node(nodelist[3])
  434.             if len(nodelist) >= 6:
  435.                 expr3 = self.com_node(nodelist[5])
  436.             else:
  437.                 expr3 = None
  438.         else:
  439.             expr2 = None
  440.             expr3 = None
  441.         return Exec(expr1, expr2, expr3, lineno = nodelist[0][2])
  442.  
  443.     
  444.     def assert_stmt(self, nodelist):
  445.         expr1 = self.com_node(nodelist[1])
  446.         if len(nodelist) == 4:
  447.             expr2 = self.com_node(nodelist[3])
  448.         else:
  449.             expr2 = None
  450.         return Assert(expr1, expr2, lineno = nodelist[0][2])
  451.  
  452.     
  453.     def if_stmt(self, nodelist):
  454.         tests = []
  455.         for i in range(0, len(nodelist) - 3, 4):
  456.             testNode = self.com_node(nodelist[i + 1])
  457.             suiteNode = self.com_node(nodelist[i + 3])
  458.             tests.append((testNode, suiteNode))
  459.         
  460.         if len(nodelist) % 4 == 3:
  461.             elseNode = self.com_node(nodelist[-1])
  462.         else:
  463.             elseNode = None
  464.         return If(tests, elseNode, lineno = nodelist[0][2])
  465.  
  466.     
  467.     def while_stmt(self, nodelist):
  468.         testNode = self.com_node(nodelist[1])
  469.         bodyNode = self.com_node(nodelist[3])
  470.         if len(nodelist) > 4:
  471.             elseNode = self.com_node(nodelist[6])
  472.         else:
  473.             elseNode = None
  474.         return While(testNode, bodyNode, elseNode, lineno = nodelist[0][2])
  475.  
  476.     
  477.     def for_stmt(self, nodelist):
  478.         assignNode = self.com_assign(nodelist[1], OP_ASSIGN)
  479.         listNode = self.com_node(nodelist[3])
  480.         bodyNode = self.com_node(nodelist[5])
  481.         if len(nodelist) > 8:
  482.             elseNode = self.com_node(nodelist[8])
  483.         else:
  484.             elseNode = None
  485.         return For(assignNode, listNode, bodyNode, elseNode, lineno = nodelist[0][2])
  486.  
  487.     
  488.     def try_stmt(self, nodelist):
  489.         if nodelist[3][0] != symbol.except_clause:
  490.             return self.com_try_finally(nodelist)
  491.         
  492.         return self.com_try_except(nodelist)
  493.  
  494.     
  495.     def suite(self, nodelist):
  496.         if len(nodelist) == 1:
  497.             return self.com_stmt(nodelist[0])
  498.         
  499.         stmts = []
  500.         for node in nodelist:
  501.             if node[0] == symbol.stmt:
  502.                 self.com_append_stmt(stmts, node)
  503.                 continue
  504.         
  505.         return Stmt(stmts)
  506.  
  507.     
  508.     def testlist(self, nodelist):
  509.         return self.com_binary(Tuple, nodelist)
  510.  
  511.     testlist_safe = testlist
  512.     testlist1 = testlist
  513.     exprlist = testlist
  514.     
  515.     def testlist_gexp(self, nodelist):
  516.         if len(nodelist) == 2 and nodelist[1][0] == symbol.gen_for:
  517.             test = self.com_node(nodelist[0])
  518.             return self.com_generator_expression(test, nodelist[1])
  519.         
  520.         return self.testlist(nodelist)
  521.  
  522.     
  523.     def test(self, nodelist):
  524.         if len(nodelist) == 1 and nodelist[0][0] == symbol.lambdef:
  525.             return self.lambdef(nodelist[0])
  526.         
  527.         return self.com_binary(Or, nodelist)
  528.  
  529.     
  530.     def and_test(self, nodelist):
  531.         return self.com_binary(And, nodelist)
  532.  
  533.     
  534.     def not_test(self, nodelist):
  535.         result = self.com_node(nodelist[-1])
  536.         if len(nodelist) == 2:
  537.             return Not(result, lineno = nodelist[0][2])
  538.         
  539.         return result
  540.  
  541.     
  542.     def comparison(self, nodelist):
  543.         node = self.com_node(nodelist[0])
  544.         if len(nodelist) == 1:
  545.             return node
  546.         
  547.         results = []
  548.         for i in range(2, len(nodelist), 2):
  549.             nl = nodelist[i - 1]
  550.             n = nl[1]
  551.             if n[0] == token.NAME:
  552.                 type = n[1]
  553.                 if len(nl) == 3:
  554.                     if type == 'not':
  555.                         type = 'not in'
  556.                     else:
  557.                         type = 'is not'
  558.                 
  559.             else:
  560.                 type = _cmp_types[n[0]]
  561.             lineno = nl[1][2]
  562.             results.append((type, self.com_node(nodelist[i])))
  563.         
  564.         return Compare(node, results, lineno = lineno)
  565.  
  566.     
  567.     def expr(self, nodelist):
  568.         return self.com_binary(Bitor, nodelist)
  569.  
  570.     
  571.     def xor_expr(self, nodelist):
  572.         return self.com_binary(Bitxor, nodelist)
  573.  
  574.     
  575.     def and_expr(self, nodelist):
  576.         return self.com_binary(Bitand, nodelist)
  577.  
  578.     
  579.     def shift_expr(self, nodelist):
  580.         node = self.com_node(nodelist[0])
  581.         for i in range(2, len(nodelist), 2):
  582.             right = self.com_node(nodelist[i])
  583.             if nodelist[i - 1][0] == token.LEFTSHIFT:
  584.                 node = LeftShift([
  585.                     node,
  586.                     right], lineno = nodelist[1][2])
  587.                 continue
  588.             if nodelist[i - 1][0] == token.RIGHTSHIFT:
  589.                 node = RightShift([
  590.                     node,
  591.                     right], lineno = nodelist[1][2])
  592.                 continue
  593.             raise ValueError, 'unexpected token: %s' % nodelist[i - 1][0]
  594.         
  595.         return node
  596.  
  597.     
  598.     def arith_expr(self, nodelist):
  599.         node = self.com_node(nodelist[0])
  600.         for i in range(2, len(nodelist), 2):
  601.             right = self.com_node(nodelist[i])
  602.             if nodelist[i - 1][0] == token.PLUS:
  603.                 node = Add([
  604.                     node,
  605.                     right], lineno = nodelist[1][2])
  606.                 continue
  607.             if nodelist[i - 1][0] == token.MINUS:
  608.                 node = Sub([
  609.                     node,
  610.                     right], lineno = nodelist[1][2])
  611.                 continue
  612.             raise ValueError, 'unexpected token: %s' % nodelist[i - 1][0]
  613.         
  614.         return node
  615.  
  616.     
  617.     def term(self, nodelist):
  618.         node = self.com_node(nodelist[0])
  619.         for i in range(2, len(nodelist), 2):
  620.             right = self.com_node(nodelist[i])
  621.             t = nodelist[i - 1][0]
  622.             if t == token.STAR:
  623.                 node = Mul([
  624.                     node,
  625.                     right])
  626.             elif t == token.SLASH:
  627.                 node = Div([
  628.                     node,
  629.                     right])
  630.             elif t == token.PERCENT:
  631.                 node = Mod([
  632.                     node,
  633.                     right])
  634.             elif t == token.DOUBLESLASH:
  635.                 node = FloorDiv([
  636.                     node,
  637.                     right])
  638.             else:
  639.                 raise ValueError, 'unexpected token: %s' % t
  640.             node.lineno = nodelist[1][2]
  641.         
  642.         return node
  643.  
  644.     
  645.     def factor(self, nodelist):
  646.         elt = nodelist[0]
  647.         t = elt[0]
  648.         node = self.lookup_node(nodelist[-1])(nodelist[-1][1:])
  649.         if t == token.PLUS:
  650.             return UnaryAdd(node, lineno = elt[2])
  651.         elif t == token.MINUS:
  652.             return UnarySub(node, lineno = elt[2])
  653.         elif t == token.TILDE:
  654.             node = Invert(node, lineno = elt[2])
  655.         
  656.         return node
  657.  
  658.     
  659.     def power(self, nodelist):
  660.         node = self.com_node(nodelist[0])
  661.         for i in range(1, len(nodelist)):
  662.             elt = nodelist[i]
  663.             if elt[0] == token.DOUBLESTAR:
  664.                 return Power([
  665.                     node,
  666.                     self.com_node(nodelist[i + 1])], lineno = elt[2])
  667.             
  668.             node = self.com_apply_trailer(node, elt)
  669.         
  670.         return node
  671.  
  672.     
  673.     def atom(self, nodelist):
  674.         return self._atom_dispatch[nodelist[0][0]](nodelist)
  675.         n.lineno = nodelist[0][2]
  676.         return n
  677.  
  678.     
  679.     def atom_lpar(self, nodelist):
  680.         if nodelist[1][0] == token.RPAR:
  681.             return Tuple(())
  682.         
  683.         return self.com_node(nodelist[1])
  684.  
  685.     
  686.     def atom_lsqb(self, nodelist):
  687.         if nodelist[1][0] == token.RSQB:
  688.             return List(())
  689.         
  690.         return self.com_list_constructor(nodelist[1])
  691.  
  692.     
  693.     def atom_lbrace(self, nodelist):
  694.         if nodelist[1][0] == token.RBRACE:
  695.             return Dict(())
  696.         
  697.         return self.com_dictmaker(nodelist[1])
  698.  
  699.     
  700.     def atom_backquote(self, nodelist):
  701.         return Backquote(self.com_node(nodelist[1]))
  702.  
  703.     
  704.     def atom_number(self, nodelist):
  705.         k = eval(nodelist[0][1])
  706.         return Const(k, lineno = nodelist[0][2])
  707.  
  708.     
  709.     def decode_literal(self, lit):
  710.         if self.encoding:
  711.             if self.encoding not in [
  712.                 'utf-8',
  713.                 'iso-8859-1']:
  714.                 lit = unicode(lit, 'utf-8').encode(self.encoding)
  715.             
  716.             return eval('# coding: %s\n%s' % (self.encoding, lit))
  717.         else:
  718.             return eval(lit)
  719.  
  720.     
  721.     def atom_string(self, nodelist):
  722.         k = ''
  723.         for node in nodelist:
  724.             k += self.decode_literal(node[1])
  725.         
  726.         return Const(k, lineno = nodelist[0][2])
  727.  
  728.     
  729.     def atom_name(self, nodelist):
  730.         return Name(nodelist[0][1], lineno = nodelist[0][2])
  731.  
  732.     
  733.     def lookup_node(self, node):
  734.         return self._dispatch[node[0]]
  735.  
  736.     _callers = { }
  737.     
  738.     def com_node(self, node):
  739.         return self._dispatch[node[0]](node[1:])
  740.  
  741.     
  742.     def com_NEWLINE(self, *args):
  743.         return Discard(Const(None))
  744.  
  745.     
  746.     def com_arglist(self, nodelist):
  747.         names = []
  748.         defaults = []
  749.         flags = 0
  750.         i = 0
  751.         while i < len(nodelist):
  752.             node = nodelist[i]
  753.             if node[0] == token.STAR or node[0] == token.DOUBLESTAR:
  754.                 if node[0] == token.STAR:
  755.                     node = nodelist[i + 1]
  756.                     if node[0] == token.NAME:
  757.                         names.append(node[1])
  758.                         flags = flags | CO_VARARGS
  759.                         i = i + 3
  760.                     
  761.                 
  762.                 if i < len(nodelist):
  763.                     t = nodelist[i][0]
  764.                     if t == token.DOUBLESTAR:
  765.                         node = nodelist[i + 1]
  766.                     else:
  767.                         raise ValueError, 'unexpected token: %s' % t
  768.                     names.append(node[1])
  769.                     flags = flags | CO_VARKEYWORDS
  770.                 
  771.                 break
  772.             
  773.             names.append(self.com_fpdef(node))
  774.             i = i + 1
  775.             if i >= len(nodelist):
  776.                 break
  777.             
  778.             if nodelist[i][0] == token.EQUAL:
  779.                 defaults.append(self.com_node(nodelist[i + 1]))
  780.                 i = i + 2
  781.             elif len(defaults):
  782.                 defaults.append(Const(None))
  783.             
  784.             i = i + 1
  785.         return (names, defaults, flags)
  786.  
  787.     
  788.     def com_fpdef(self, node):
  789.         if node[1][0] == token.LPAR:
  790.             return self.com_fplist(node[2])
  791.         
  792.         return node[1][1]
  793.  
  794.     
  795.     def com_fplist(self, node):
  796.         if len(node) == 2:
  797.             return self.com_fpdef(node[1])
  798.         
  799.         list = []
  800.         for i in range(1, len(node), 2):
  801.             list.append(self.com_fpdef(node[i]))
  802.         
  803.         return tuple(list)
  804.  
  805.     
  806.     def com_dotted_name(self, node):
  807.         name = ''
  808.         for n in node:
  809.             if type(n) == type(()) and n[0] == 1:
  810.                 name = name + n[1] + '.'
  811.                 continue
  812.         
  813.         return name[:-1]
  814.  
  815.     
  816.     def com_dotted_as_name(self, node):
  817.         node = node[1:]
  818.         dot = self.com_dotted_name(node[0][1:])
  819.         if len(node) == 1:
  820.             return (dot, None)
  821.         
  822.         return (dot, node[2][1])
  823.  
  824.     
  825.     def com_dotted_as_names(self, node):
  826.         node = node[1:]
  827.         names = [
  828.             self.com_dotted_as_name(node[0])]
  829.         for i in range(2, len(node), 2):
  830.             names.append(self.com_dotted_as_name(node[i]))
  831.         
  832.         return names
  833.  
  834.     
  835.     def com_import_as_name(self, node):
  836.         node = node[1:]
  837.         if len(node) == 1:
  838.             return (node[0][1], None)
  839.         
  840.         return (node[0][1], node[2][1])
  841.  
  842.     
  843.     def com_import_as_names(self, node):
  844.         node = node[1:]
  845.         names = [
  846.             self.com_import_as_name(node[0])]
  847.         for i in range(2, len(node), 2):
  848.             names.append(self.com_import_as_name(node[i]))
  849.         
  850.         return names
  851.  
  852.     
  853.     def com_bases(self, node):
  854.         bases = []
  855.         for i in range(1, len(node), 2):
  856.             bases.append(self.com_node(node[i]))
  857.         
  858.         return bases
  859.  
  860.     
  861.     def com_try_finally(self, nodelist):
  862.         return TryFinally(self.com_node(nodelist[2]), self.com_node(nodelist[5]), lineno = nodelist[0][2])
  863.  
  864.     
  865.     def com_try_except(self, nodelist):
  866.         stmt = self.com_node(nodelist[2])
  867.         clauses = []
  868.         elseNode = None
  869.         for i in range(3, len(nodelist), 3):
  870.             node = nodelist[i]
  871.             if node[0] == symbol.except_clause:
  872.                 if len(node) > 2:
  873.                     expr1 = self.com_node(node[2])
  874.                     if len(node) > 4:
  875.                         expr2 = self.com_assign(node[4], OP_ASSIGN)
  876.                     else:
  877.                         expr2 = None
  878.                 else:
  879.                     expr1 = None
  880.                     expr2 = None
  881.                 clauses.append((expr1, expr2, self.com_node(nodelist[i + 2])))
  882.             
  883.             if node[0] == token.NAME:
  884.                 elseNode = self.com_node(nodelist[i + 2])
  885.                 continue
  886.         
  887.         return TryExcept(self.com_node(nodelist[2]), clauses, elseNode, lineno = nodelist[0][2])
  888.  
  889.     
  890.     def com_augassign_op(self, node):
  891.         return node[1]
  892.  
  893.     
  894.     def com_augassign(self, node):
  895.         '''Return node suitable for lvalue of augmented assignment
  896.  
  897.         Names, slices, and attributes are the only allowable nodes.
  898.         '''
  899.         l = self.com_node(node)
  900.         if l.__class__ in (Name, Slice, Subscript, Getattr):
  901.             return l
  902.         
  903.         raise SyntaxError, "can't assign to %s" % l.__class__.__name__
  904.  
  905.     
  906.     def com_assign(self, node, assigning):
  907.         while None:
  908.             t = node[0]
  909.             if t == symbol.exprlist and t == symbol.testlist or t == symbol.testlist_gexp:
  910.                 if len(node) > 2:
  911.                     return self.com_assign_tuple(node, assigning)
  912.                 
  913.                 node = node[1]
  914.                 continue
  915.             if t in _assign_types:
  916.                 if len(node) > 2:
  917.                     raise SyntaxError, "can't assign to operator"
  918.                 
  919.                 node = node[1]
  920.                 continue
  921.             None if t == symbol.power else t == token.LPAR
  922.             raise SyntaxError, 'bad assignment'
  923.  
  924.     
  925.     def com_assign_tuple(self, node, assigning):
  926.         assigns = []
  927.         for i in range(1, len(node), 2):
  928.             assigns.append(self.com_assign(node[i], assigning))
  929.         
  930.         return AssTuple(assigns, lineno = extractLineNo(node))
  931.  
  932.     
  933.     def com_assign_list(self, node, assigning):
  934.         assigns = []
  935.         for i in range(1, len(node), 2):
  936.             if i + 1 < len(node):
  937.                 if node[i + 1][0] == symbol.list_for:
  938.                     raise SyntaxError, "can't assign to list comprehension"
  939.                 
  940.             
  941.             assigns.append(self.com_assign(node[i], assigning))
  942.         
  943.         return AssList(assigns, lineno = extractLineNo(node))
  944.  
  945.     
  946.     def com_assign_name(self, node, assigning):
  947.         return AssName(node[1], assigning, lineno = node[2])
  948.  
  949.     
  950.     def com_assign_trailer(self, primary, node, assigning):
  951.         t = node[1][0]
  952.         if t == token.DOT:
  953.             return self.com_assign_attr(primary, node[2], assigning)
  954.         
  955.         if t == token.LSQB:
  956.             return self.com_subscriptlist(primary, node[2], assigning)
  957.         
  958.         if t == token.LPAR:
  959.             raise SyntaxError, "can't assign to function call"
  960.         
  961.         raise SyntaxError, 'unknown trailer type: %s' % t
  962.  
  963.     
  964.     def com_assign_attr(self, primary, node, assigning):
  965.         return AssAttr(primary, node[1], assigning, lineno = node[-1])
  966.  
  967.     
  968.     def com_binary(self, constructor, nodelist):
  969.         """Compile 'NODE (OP NODE)*' into (type, [ node1, ..., nodeN ])."""
  970.         l = len(nodelist)
  971.         if l == 1:
  972.             n = nodelist[0]
  973.             return self.lookup_node(n)(n[1:])
  974.         
  975.         items = []
  976.         for i in range(0, l, 2):
  977.             n = nodelist[i]
  978.             items.append(self.lookup_node(n)(n[1:]))
  979.         
  980.         return constructor(items, lineno = extractLineNo(nodelist))
  981.  
  982.     
  983.     def com_stmt(self, node):
  984.         result = self.lookup_node(node)(node[1:])
  985.         if isinstance(result, Stmt):
  986.             return result
  987.         
  988.         return Stmt([
  989.             result])
  990.  
  991.     
  992.     def com_append_stmt(self, stmts, node):
  993.         result = self.lookup_node(node)(node[1:])
  994.         if isinstance(result, Stmt):
  995.             stmts.extend(result.nodes)
  996.         else:
  997.             stmts.append(result)
  998.  
  999.     if hasattr(symbol, 'list_for'):
  1000.         
  1001.         def com_list_constructor(self, nodelist):
  1002.             values = []
  1003.             for i in range(1, len(nodelist)):
  1004.                 if nodelist[i][0] == symbol.list_for:
  1005.                     return self.com_list_comprehension(values[0], nodelist[i])
  1006.                 elif nodelist[i][0] == token.COMMA:
  1007.                     continue
  1008.                 
  1009.                 values.append(self.com_node(nodelist[i]))
  1010.             
  1011.             return List(values, lineno = values[0].lineno)
  1012.  
  1013.         
  1014.         def com_list_comprehension(self, expr, node):
  1015.             lineno = node[1][2]
  1016.             fors = []
  1017.             while node:
  1018.                 t = node[1][1]
  1019.                 if t == 'for':
  1020.                     assignNode = self.com_assign(node[2], OP_ASSIGN)
  1021.                     listNode = self.com_node(node[4])
  1022.                     newfor = ListCompFor(assignNode, listNode, [])
  1023.                     newfor.lineno = node[1][2]
  1024.                     fors.append(newfor)
  1025.                     if len(node) == 5:
  1026.                         node = None
  1027.                     else:
  1028.                         node = self.com_list_iter(node[5])
  1029.                 len(node) == 5
  1030.                 if t == 'if':
  1031.                     test = self.com_node(node[2])
  1032.                     newif = ListCompIf(test, lineno = node[1][2])
  1033.                     newfor.ifs.append(newif)
  1034.                     if len(node) == 3:
  1035.                         node = None
  1036.                     else:
  1037.                         node = self.com_list_iter(node[3])
  1038.                 len(node) == 3
  1039.                 raise SyntaxError, 'unexpected list comprehension element: %s %d' % (node, lineno)
  1040.             return ListComp(expr, fors, lineno = lineno)
  1041.  
  1042.         
  1043.         def com_list_iter(self, node):
  1044.             return node[1]
  1045.  
  1046.     else:
  1047.         
  1048.         def com_list_constructor(self, nodelist):
  1049.             values = []
  1050.             for i in range(1, len(nodelist), 2):
  1051.                 values.append(self.com_node(nodelist[i]))
  1052.             
  1053.             return List(values)
  1054.  
  1055.     if hasattr(symbol, 'gen_for'):
  1056.         
  1057.         def com_generator_expression(self, expr, node):
  1058.             lineno = node[1][2]
  1059.             fors = []
  1060.             while node:
  1061.                 t = node[1][1]
  1062.                 if t == 'for':
  1063.                     assignNode = self.com_assign(node[2], OP_ASSIGN)
  1064.                     genNode = self.com_node(node[4])
  1065.                     newfor = GenExprFor(assignNode, genNode, [], lineno = node[1][2])
  1066.                     fors.append(newfor)
  1067.                     if len(node) == 5:
  1068.                         node = None
  1069.                     else:
  1070.                         node = self.com_gen_iter(node[5])
  1071.                 len(node) == 5
  1072.                 if t == 'if':
  1073.                     test = self.com_node(node[2])
  1074.                     newif = GenExprIf(test, lineno = node[1][2])
  1075.                     newfor.ifs.append(newif)
  1076.                     if len(node) == 3:
  1077.                         node = None
  1078.                     else:
  1079.                         node = self.com_gen_iter(node[3])
  1080.                 len(node) == 3
  1081.                 raise SyntaxError, 'unexpected generator expression element: %s %d' % (node, lineno)
  1082.             fors[0].is_outmost = True
  1083.             return GenExpr(GenExprInner(expr, fors), lineno = lineno)
  1084.  
  1085.         
  1086.         def com_gen_iter(self, node):
  1087.             return node[1]
  1088.  
  1089.     
  1090.     
  1091.     def com_dictmaker(self, nodelist):
  1092.         items = []
  1093.         for i in range(1, len(nodelist), 4):
  1094.             items.append((self.com_node(nodelist[i]), self.com_node(nodelist[i + 2])))
  1095.         
  1096.         return Dict(items)
  1097.  
  1098.     
  1099.     def com_apply_trailer(self, primaryNode, nodelist):
  1100.         t = nodelist[1][0]
  1101.         if t == token.LPAR:
  1102.             return self.com_call_function(primaryNode, nodelist[2])
  1103.         
  1104.         if t == token.DOT:
  1105.             return self.com_select_member(primaryNode, nodelist[2])
  1106.         
  1107.         if t == token.LSQB:
  1108.             return self.com_subscriptlist(primaryNode, nodelist[2], OP_APPLY)
  1109.         
  1110.         raise SyntaxError, 'unknown node type: %s' % t
  1111.  
  1112.     
  1113.     def com_select_member(self, primaryNode, nodelist):
  1114.         if nodelist[0] != token.NAME:
  1115.             raise SyntaxError, 'member must be a name'
  1116.         
  1117.         return Getattr(primaryNode, nodelist[1], lineno = nodelist[2])
  1118.  
  1119.     
  1120.     def com_call_function(self, primaryNode, nodelist):
  1121.         if nodelist[0] == token.RPAR:
  1122.             return CallFunc(primaryNode, [], lineno = extractLineNo(nodelist))
  1123.         
  1124.         args = []
  1125.         kw = 0
  1126.         len_nodelist = len(nodelist)
  1127.         for i in range(1, len_nodelist, 2):
  1128.             node = nodelist[i]
  1129.             if node[0] == token.STAR or node[0] == token.DOUBLESTAR:
  1130.                 break
  1131.             
  1132.             (kw, result) = self.com_argument(node, kw)
  1133.             if len_nodelist != 2 and isinstance(result, GenExpr) and len(node) == 3 and node[2][0] == symbol.gen_for:
  1134.                 raise SyntaxError, 'generator expression needs parenthesis'
  1135.             
  1136.             args.append(result)
  1137.         else:
  1138.             i = i + 1
  1139.         if i < len_nodelist and nodelist[i][0] == token.COMMA:
  1140.             i = i + 1
  1141.         
  1142.         star_node = None
  1143.         dstar_node = None
  1144.         while i < len_nodelist:
  1145.             tok = nodelist[i]
  1146.             ch = nodelist[i + 1]
  1147.             i = i + 3
  1148.             if tok[0] == token.STAR:
  1149.                 if star_node is not None:
  1150.                     raise SyntaxError, 'already have the varargs indentifier'
  1151.                 
  1152.                 star_node = self.com_node(ch)
  1153.                 continue
  1154.             if tok[0] == token.DOUBLESTAR:
  1155.                 if dstar_node is not None:
  1156.                     raise SyntaxError, 'already have the kwargs indentifier'
  1157.                 
  1158.                 dstar_node = self.com_node(ch)
  1159.                 continue
  1160.             raise SyntaxError, 'unknown node type: %s' % tok
  1161.         return CallFunc(primaryNode, args, star_node, dstar_node, lineno = extractLineNo(nodelist))
  1162.  
  1163.     
  1164.     def com_argument(self, nodelist, kw):
  1165.         if len(nodelist) == 3 and nodelist[2][0] == symbol.gen_for:
  1166.             test = self.com_node(nodelist[1])
  1167.             return (0, self.com_generator_expression(test, nodelist[2]))
  1168.         
  1169.         if len(nodelist) == 2:
  1170.             if kw:
  1171.                 raise SyntaxError, 'non-keyword arg after keyword arg'
  1172.             
  1173.             return (0, self.com_node(nodelist[1]))
  1174.         
  1175.         result = self.com_node(nodelist[3])
  1176.         n = nodelist[1]
  1177.         while len(n) == 2 and n[0] != token.NAME:
  1178.             n = n[1]
  1179.         if n[0] != token.NAME:
  1180.             raise SyntaxError, "keyword can't be an expression (%s)" % n[0]
  1181.         
  1182.         node = Keyword(n[1], result, lineno = n[2])
  1183.         return (1, node)
  1184.  
  1185.     
  1186.     def com_subscriptlist(self, primary, nodelist, assigning):
  1187.         if len(nodelist) == 2:
  1188.             sub = nodelist[1]
  1189.             if (sub[1][0] == token.COLON or len(sub) > 2 or sub[2][0] == token.COLON) and sub[-1][0] != symbol.sliceop:
  1190.                 return self.com_slice(primary, sub, assigning)
  1191.             
  1192.         
  1193.         subscripts = []
  1194.         for i in range(1, len(nodelist), 2):
  1195.             subscripts.append(self.com_subscript(nodelist[i]))
  1196.         
  1197.         return Subscript(primary, assigning, subscripts, lineno = extractLineNo(nodelist))
  1198.  
  1199.     
  1200.     def com_subscript(self, node):
  1201.         ch = node[1]
  1202.         t = ch[0]
  1203.         if t == token.DOT and node[2][0] == token.DOT:
  1204.             return Ellipsis()
  1205.         
  1206.         if t == token.COLON or len(node) > 2:
  1207.             return self.com_sliceobj(node)
  1208.         
  1209.         return self.com_node(ch)
  1210.  
  1211.     
  1212.     def com_sliceobj(self, node):
  1213.         items = []
  1214.         if node[1][0] == token.COLON:
  1215.             items.append(Const(None))
  1216.             i = 2
  1217.         else:
  1218.             items.append(self.com_node(node[1]))
  1219.             i = 3
  1220.         if i < len(node) and node[i][0] == symbol.test:
  1221.             items.append(self.com_node(node[i]))
  1222.             i = i + 1
  1223.         else:
  1224.             items.append(Const(None))
  1225.         for j in range(i, len(node)):
  1226.             ch = node[j]
  1227.             if len(ch) == 2:
  1228.                 items.append(Const(None))
  1229.                 continue
  1230.             items.append(self.com_node(ch[2]))
  1231.         
  1232.         return Sliceobj(items, lineno = extractLineNo(node))
  1233.  
  1234.     
  1235.     def com_slice(self, primary, node, assigning):
  1236.         lower = None
  1237.         upper = None
  1238.         if len(node) == 3:
  1239.             if node[1][0] == token.COLON:
  1240.                 upper = self.com_node(node[2])
  1241.             else:
  1242.                 lower = self.com_node(node[1])
  1243.         elif len(node) == 4:
  1244.             lower = self.com_node(node[1])
  1245.             upper = self.com_node(node[3])
  1246.         
  1247.         return Slice(primary, assigning, lower, upper, lineno = extractLineNo(node))
  1248.  
  1249.     
  1250.     def get_docstring(self, node, n = None):
  1251.         if n is None:
  1252.             n = node[0]
  1253.             node = node[1:]
  1254.         
  1255.         if n == symbol.suite:
  1256.             if len(node) == 1:
  1257.                 return self.get_docstring(node[0])
  1258.             
  1259.             for sub in node:
  1260.                 if sub[0] == symbol.stmt:
  1261.                     return self.get_docstring(sub)
  1262.                     continue
  1263.             
  1264.             return None
  1265.         
  1266.         if n == symbol.file_input:
  1267.             for sub in node:
  1268.                 if sub[0] == symbol.stmt:
  1269.                     return self.get_docstring(sub)
  1270.                     continue
  1271.             
  1272.             return None
  1273.         
  1274.         if n == symbol.atom:
  1275.             if node[0][0] == token.STRING:
  1276.                 s = ''
  1277.                 for t in node:
  1278.                     s = s + eval(t[1])
  1279.                 
  1280.                 return s
  1281.             
  1282.             return None
  1283.         
  1284.         if n == symbol.stmt and n == symbol.simple_stmt or n == symbol.small_stmt:
  1285.             return self.get_docstring(node[0])
  1286.         
  1287.         if n in _doc_nodes and len(node) == 1:
  1288.             return self.get_docstring(node[0])
  1289.         
  1290.  
  1291.  
  1292. _doc_nodes = [
  1293.     symbol.expr_stmt,
  1294.     symbol.testlist,
  1295.     symbol.testlist_safe,
  1296.     symbol.test,
  1297.     symbol.and_test,
  1298.     symbol.not_test,
  1299.     symbol.comparison,
  1300.     symbol.expr,
  1301.     symbol.xor_expr,
  1302.     symbol.and_expr,
  1303.     symbol.shift_expr,
  1304.     symbol.arith_expr,
  1305.     symbol.term,
  1306.     symbol.factor,
  1307.     symbol.power]
  1308. _cmp_types = {
  1309.     token.LESS: '<',
  1310.     token.GREATER: '>',
  1311.     token.EQEQUAL: '==',
  1312.     token.EQUAL: '==',
  1313.     token.LESSEQUAL: '<=',
  1314.     token.GREATEREQUAL: '>=',
  1315.     token.NOTEQUAL: '!=' }
  1316. _legal_node_types = [
  1317.     symbol.funcdef,
  1318.     symbol.classdef,
  1319.     symbol.stmt,
  1320.     symbol.small_stmt,
  1321.     symbol.flow_stmt,
  1322.     symbol.simple_stmt,
  1323.     symbol.compound_stmt,
  1324.     symbol.expr_stmt,
  1325.     symbol.print_stmt,
  1326.     symbol.del_stmt,
  1327.     symbol.pass_stmt,
  1328.     symbol.break_stmt,
  1329.     symbol.continue_stmt,
  1330.     symbol.return_stmt,
  1331.     symbol.raise_stmt,
  1332.     symbol.import_stmt,
  1333.     symbol.global_stmt,
  1334.     symbol.exec_stmt,
  1335.     symbol.assert_stmt,
  1336.     symbol.if_stmt,
  1337.     symbol.while_stmt,
  1338.     symbol.for_stmt,
  1339.     symbol.try_stmt,
  1340.     symbol.suite,
  1341.     symbol.testlist,
  1342.     symbol.testlist_safe,
  1343.     symbol.test,
  1344.     symbol.and_test,
  1345.     symbol.not_test,
  1346.     symbol.comparison,
  1347.     symbol.exprlist,
  1348.     symbol.expr,
  1349.     symbol.xor_expr,
  1350.     symbol.and_expr,
  1351.     symbol.shift_expr,
  1352.     symbol.arith_expr,
  1353.     symbol.term,
  1354.     symbol.factor,
  1355.     symbol.power,
  1356.     symbol.atom]
  1357. if hasattr(symbol, 'yield_stmt'):
  1358.     _legal_node_types.append(symbol.yield_stmt)
  1359.  
  1360. _assign_types = [
  1361.     symbol.test,
  1362.     symbol.and_test,
  1363.     symbol.not_test,
  1364.     symbol.comparison,
  1365.     symbol.expr,
  1366.     symbol.xor_expr,
  1367.     symbol.and_expr,
  1368.     symbol.shift_expr,
  1369.     symbol.arith_expr,
  1370.     symbol.term,
  1371.     symbol.factor]
  1372. import types
  1373. _names = { }
  1374. for k, v in symbol.sym_name.items():
  1375.     _names[k] = v
  1376.  
  1377. for k, v in token.tok_name.items():
  1378.     _names[k] = v
  1379.  
  1380.  
  1381. def debug_tree(tree):
  1382.     l = []
  1383.     for elt in tree:
  1384.         if type(elt) == types.IntType:
  1385.             l.append(_names.get(elt, elt))
  1386.             continue
  1387.         if type(elt) == types.StringType:
  1388.             l.append(elt)
  1389.             continue
  1390.         l.append(debug_tree(elt))
  1391.     
  1392.     return l
  1393.  
  1394.